home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 May / EnigmA AMIGA RUN 07 (1996)(G.R. Edizioni)(IT)[!][issue 1996-05][EARSAN CD VI].iso / docs / corsoguide / segnali-7.txt < prev    next >
Text File  |  1992-09-03  |  5KB  |  87 lines
  1. I segnali (signals)
  2.  
  3. I segnali (da non confondere con quelli di fumo che, se emessi dal vostro
  4. calcolatore sono indice di qualcosa di grave) sono il mezzo a disposizione
  5. di exec per "segnalare" al task che si è verificata una situazione per cui
  6. quest'ultimo aveva chiesto di essere avvertito.
  7. Questo meccanismo è molto importante per un sistema multitasking quale è
  8. l'Amiga; infatti i processi (o task) vengono classificati con dei stati a
  9. seconda del momento; in particolare dato che l'Amiga ha un solo processore,
  10. questo deve essere diviso fra più task simulando più CPU virtuali; per far
  11. questo viene dedicato ad ogni task un determinato quanto di tempo, alla
  12. scadenza del quale il task viene momentaneamente congelato (con i contenuti
  13. dei registri del microprocessore) per attivare un altro task (ciò che viene
  14. definito multitasking pre-emptive); come potete osservare il task può
  15. venire a trovarsi in diverse situazioni e più precisamente 3: attivo
  16. (running), pronto (ready), addormentato (sleeping). Il task è in stato di
  17. attivo quando è effettivamente in esecuzione, in stato pronto quando
  18. attende di essere attivato dato che il microprocessore sta eseguendo un
  19. altro task, ma quello che ci interessa al momento è lo stato di
  20. addormentato; capita sovente infatti, che il programma debba attendere
  21. senza far nulla un evento di I/O (pressione del taso del mouse o della
  22. tastiera ecc.), per cui il tempo messo a sua disposizione verrebbe
  23. totalmente sprecato dato che quest'ultimo potrebbe essere utilizzato da
  24. altri task, ed il s.o. gli ridarebbe il controllo quando si verifica
  25. l'evento di I/O atteso, ed è proprio a questo che serve lo stato di
  26. addormentato; infatti il programma può chiedere di essere momentaneamente
  27. "addormentato" tramite la funzione Wait di exec e verrà risvegliato solo
  28. quando verrà raggiunto da un segnale (che potrà essere spedito dal s.o.
  29. oppure da un altro task per un messaggio); un segnale è identificato da un
  30. particolare bit in una maschera data da una LONG; il ché significa che
  31. possono essere in circolazione al massimo 32 segnali per un task (di cui 16
  32. riservati al s.o.), per cui bisogna innanzitutto chiederne l'uso al s.o. e
  33. liberarlo al più presto; in realtà non capita mai di utilizzare i segnali
  34. direttamente a meno di non voler segnalare un altro task (creato ovviamente
  35. dallo stesso programma) di effettuare una qualsiasi azione e comunque per
  36. la comunicazione fra task si utilizzano normalmente le porte ed i messaggi
  37. che fanno ugualmente uso di questo meccanismo; la funzione importante è
  38. ovviamente Wait che permette al programma di andare in stato di sleeping
  39. ottimizzando così le risorse di sistema; le funzioni per
  40. allocare/deallocare i segnali sono:
  41.  
  42. NumSegnale = AllocSignal(NumSegnale);
  43. FreeSignal(NumSegnale);
  44.  
  45. dove NumSegnale è il numero di segnale da allocare (che va da 16 a 31 dato
  46. che i primi 16 sono occupati dal s.o.); AllocSignal alloca e riserva l'uso
  47. del segnale NumSegnale, il valore ritornato vale -1 se non è stato possibile
  48. allocare il segnale, oppure vale il codice del segnale allocato in caso
  49. contrario; FreeSignal rilascia l'uso del segnale precedentemente occupato,
  50. al sistema; c'è la possibiltà quando si alloca un segnale, e conviene
  51. utilizzarla, di non specificare un preciso segnale ma di farsi rilasciare il
  52. primo libero utilizzando come parametro di AllocSignal -1.
  53. Ma la funzione di exec più importante riguardante i segnali, e che la
  54. ritroveremo più avanti, è la funzione Wait che permette di mandare il task
  55. in stato di sleeping in attesa di qualche segnale che lo svegli:
  56.  
  57. Segnali = Wait(SetSegnali);
  58.  
  59. dove SetSegnali indica per quali segnali il task deve essere riattivato e il
  60. valore ritornato Segnali (ambedue di tipo LONG) indica quale segnale ha
  61. risvegliato il task; SetSegnali è una maschera a cui ogni segnale di valore
  62. NumSegnale (ritornato da AllocSignal) corrisponde il bit di posizione n,
  63. dove n equivale a NumSegnale (se tale bit è ad 1 Wait attenderà per quel
  64. segnale altrimenti no); questo per permettere di specificare più segnali per
  65. il risveglio di un task, di conseguenza Segnali sarà dello stesso tipo
  66. esempio:
  67.  
  68. Segnali = Wait(1<<NumSegnale | 4);
  69. if (Segnali & 1<<NumSegnale)
  70.   printf("Task risvegliato dal segnale allocato.\n");
  71.  
  72. Il piccolo esempio pone il task in sleeping per il segnale NumSegnale
  73. allocato in precedenza e per il segnale 2 (4 = 1<<2) del s.o., quindi si
  74. verifica se il segnale che ha risvegliato il task è NumSegnale nel qual caso
  75. stampa un messaggio di conferma. Vi è anche la possibilità di verificare se
  76. un segnale è arrivato senza necessariamente mandare il task in sleeping
  77. tramite questa funzione di exec: SetSignal (vedere i doc per questo);
  78. l'ultima funzione da esaminare riguardo i segnali è Signal che permette al
  79. programma di inviare un qualsiasi segnale ad un task:
  80.  
  81. Signal(Task,SetSegnali);
  82.  
  83. dove Task è il puntatore ad una struttura Task che identifica il task a cui
  84. mandare il segnale (vedremo nella prossima puntata la struttura Task) e
  85. SetSegnali è la long tipo quella specificata in Wait contenente i bit dei
  86. segnali da inviare al task.
  87.